import { useEffect, useState } from 'react';
import { makeToast } from '@nova-hf/ui';
import {
  ApplicableVariantsPayload,
  ContractStatus,
  useContractApplicableVariantsLazyQuery,
  useContractsForApplicableVariantsLazyQuery,
} from 'typings/graphql';

import { CardItem } from '../components/SellingCardItem';

export const createCardItemFromVariable = (variable: ApplicableVariantsPayload): CardItem => {
  return {
    id: variable.variant.id,
    title: variable.variant.shortName,
    description: variable.variant.description ?? '',
    price: variable.variant.minTotalSubscriptionFee ?? 0,
    isCurrent: !!variable.isCurrent && !variable.isApplicable,
    isUnavailable:
      !variable?.variant?.hasContractProductNeeded &&
      !!variable?.variant?.contractProductsNeeded?.length,
    unavailableDescription: variable?.variant.qualificationDescription ?? '',
    isApplicable: !!variable?.isApplicableImmediately,
    options: variable?.variant?.options,
    isHidden: variable?.variant?.isHidden,
  };
};

type useApplicationVariantsHookProps = {
  customerId: string;
  serviceId?: string;
  contractId?: string;
  isStaff?: boolean;
};

export const useFetchApplicableVariants = ({
  customerId,
  serviceId,
  contractId,
  isStaff,
}: useApplicationVariantsHookProps) => {
  const [loading, setLoading] = useState<boolean>(true);
  const [error, setError] = useState<string>();
  const [currentContractAsCardItem, setCurrentContractAsCardIem] = useState<CardItem>();
  const [applicableVariantsAsCardItems, setApplicableVariantsAsCardItems] = useState<CardItem[]>();
  const twoPointFiveId = 'ljos-otakmarkad-2500-mpbs-askrift';
  const tenGbSpeedId = 'ljos-otakmarkad-10000-mpbs-askrift';
  const fiveHundredIds = ['ljos-500-gb-1000-mpbs-askrift', 'ljos-500-gb-1000-mpbs-thjonusta'];

  const [getApplicableVariants, { data: variantData }] = useContractApplicableVariantsLazyQuery({
    onCompleted: () => setLoading(false),
    onError: ({ message }) => setError(message),
  });

  const [contractsQuery] = useContractsForApplicableVariantsLazyQuery({
    onCompleted: (data) => {
      const contract = data?.contracts.contracts.find(
        (contract) =>
          contract.status === ContractStatus.Active || contract.status === ContractStatus.Pending,
      );
      if (data?.contracts?.contracts?.length && contract?.id) {
        try {
          getApplicableVariants({
            variables: {
              input: {
                contractId: contract.id,
              },
            },
          });
        } catch (error) {
          if (error instanceof Error) {
            makeToast.danger('', error.message);
          }
        }
      }
    },
    onError: ({ message }) => setError(message),
  });

  useEffect(() => {
    if (serviceId && customerId) {
      contractsQuery({
        variables: {
          input: {
            customerId,
            serviceId,
          },
        },
      });
    }
    if (contractId) {
      try {
        getApplicableVariants({
          variables: {
            input: {
              contractId: contractId,
            },
          },
        });
      } catch (error) {
        if (error instanceof Error) {
          makeToast.danger('', error.message);
        }
      }
    }
  }, [customerId, serviceId, contractId]);

  useEffect(() => {
    if (variantData?.contractApplicableVariants?.length) {
      const usedData = variantData?.contractApplicableVariants;
      const applicableVariantsCardItems: (CardItem | undefined)[] = usedData.map((variant) => {
        if (
          (variant?.__typename === 'ApplicableVariantsPayload' &&
            variant?.variant?.id &&
            !variant?.variant?.isHidden &&
            variant?.variant?.id !== twoPointFiveId &&
            variant?.variant?.id !== tenGbSpeedId) ||
          (fiveHundredIds.includes(variant?.variant?.id ?? '') && isStaff)
        ) {
          return createCardItemFromVariable(variant as ApplicableVariantsPayload);
        }
      });
      if (!!applicableVariantsCardItems && applicableVariantsCardItems?.length) {
        setApplicableVariantsAsCardItems(
          applicableVariantsCardItems.filter((n) => n) as CardItem[],
        );
      }

      const currentContract = usedData.find((variant) => variant?.isCurrent);

      const currVariantAsCardItem =
        currentContract?.__typename === 'ApplicableVariantsPayload'
          ? createCardItemFromVariable(currentContract as ApplicableVariantsPayload)
          : undefined;

      setCurrentContractAsCardIem(currVariantAsCardItem);
    }
  }, [variantData]);

  return {
    currentContractAsCardItem,
    applicableVariantsAsCardItems,
    loading,
    error,
  };
};

export default useFetchApplicableVariants;